package com.xjh.utils.util;

/**
 * @Author XuJianHua
 * @Date 2022/12/12 22:19
 * @Description
 */



import org.apache.commons.lang3.ArrayUtils;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 校验参数，不合法抛出异常
 *
 * @author keji-3
 */
public class TipUtil {

    /**
     * 为true抛异常
     *
     * @param b
     * @param msg 提示消息
     */
    public static void isTrueMsg(boolean b, String msg) {
        if (b) {
            throw new TipException(msg);
        }
    }

    public static void tip(String msg) {

            throw new TipException(msg);

    }

    /**
     * 为null时抛异常
     *
     * @param o
     * @param msg
     */
    public static void isNullMsg(Object o, String msg) {
        if (o == null) {
            throw new TipException(msg);
        }
    }

    /**
     * 为false抛异常
     *
     * @param b
     * @param msg 提示消息
     */
    public static void isFalseMsg(boolean b, String msg) {
        if (!b) {
            throw new TipException(msg);
        }
    }

    /**
     * object为空时抛出异常
     *
     * @param o        对象 String,List,Map,Object[],int[],long[]
     * @param propName 提示属性名
     * @throws TipException 抛出异常为message+"不能为空"
     */
    public static void isBlank(Object o, String propName) {
        if (isBlank(o)) {
            throw new TipException(propName + "不能为空");
        }
    }

    /**
     * object为空或者超过最大长度时抛出异常
     *
     * @param inputVal
     * @param maxLength
     * @param propName
     */
    public static void isBlankOrGreaterLength(String inputVal, int maxLength, String propName) {
        if (isBlank(inputVal)) {
            throw new TipException(propName + "不能为空");
        }
        int currLength = inputVal == null ? 0 : inputVal.length();
        if (currLength > maxLength) {
            throw new TipException(propName + "长度不能超过" + maxLength);
        }
    }

    /**
     * object为空时抛出异常
     *
     * @param o   对象 String,List,Map,Object[],int[],long[]
     * @param msg 提示消息
     * @throws TipException 抛出异常为message+"不能为空"
     */
    public static void isBlankMsg(Object o, String msg) {
        if (isBlank(o)) {
            throw new TipException(msg);
        }
    }


    /**
     * object为空时抛出异常
     *
     * @param o   对象 String,List,Map,Object[],int[],long[]
     * @param msg 提示消息
     * @throws TipException 抛出异常为message+"不能为空"
     */
    public static void isNotBlankMsg(Object o, String msg) {
        if (!isBlank(o)) {
            throw new TipException(msg);
        }
    }

    /**
     * object不能为空
     *
     * @param o 对象 String,List,Map,Object[],int[],long[]
     * @return 为空返回true
     */
    private static boolean isBlank(Object o) {
        boolean flag = false;
        if (o == null) {
            flag = true;
        }
        if (o instanceof String) {
            if (o.toString().trim().equals("")) {
                flag = true;
            }
        } else if (o instanceof List) {
            if (((List) o).size() == 0) {
                flag = true;
            }
        } else if (o instanceof Map) {
            if (((Map) o).size() == 0) {
                flag = true;
            }
        } else if (o instanceof Set) {
            if (((Set) o).size() == 0) {
                flag = true;
            }
        } else if (o instanceof Object[]) {
            if (((Object[]) o).length == 0) {
                flag = true;
            }
        } else if (o instanceof int[]) {
            if (((int[]) o).length == 0) {
                flag = true;
            }
        } else if (o instanceof long[]) {
            if (((long[]) o).length == 0) {
                flag = true;
            }
        } else if (o instanceof byte[]) {
            if (((byte[]) o).length == 0) {
                flag = true;
            }
        }
        return flag;
    }

    /**
     * 对比输入数据与正确数据，相等就抛出提示异常
     *
     * @param inputVal
     * @param correctVal
     * @param msg
     */
    public static void isEqualMsg(boolean inputVal, boolean correctVal, String msg) {
        if (inputVal == correctVal) {
            throw new TipException(msg);
        }
    }

    /**
     * 对比输入数据与正确数据，相等就抛出提示异常
     *
     * @param inputVal
     * @param correctVal
     * @param msg
     */
    public static void isEqualMsg(String inputVal, String correctVal, String msg) {
        boolean equ = inputVal == null ? correctVal == null : (correctVal == null ? false : inputVal.equals(correctVal));
        if (equ) {
            throw new TipException(msg);
        }
    }

    /**
     * 对比输入数据与正确数据，不相等就抛出提示异常
     *
     * @param inputVal
     * @param correctVal
     * @param msg
     */
    public static void isNotEqualMsg(String inputVal, String correctVal, String msg) {
        boolean equ = inputVal == null ? correctVal == null : (correctVal == null ? false : inputVal.equals(correctVal));
        if (!equ) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入数据不在correctValArr中就抛出异常
     *
     * @param inputVal      输入数据
     * @param correctValArr 数组
     * @param msg
     */
    public static void isNotContainMsg(String inputVal, String[] correctValArr, String msg) {
        if (!ArrayUtils.contains(correctValArr, inputVal)) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入数据在correctValArr中就抛出异常
     *
     * @param inputVal      输入数据
     * @param correctValArr 数组
     * @param msg
     */
    public static void isContainMsg(String inputVal, String[] correctValArr, String msg) {
        if (ArrayUtils.contains(correctValArr, inputVal)) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入数据不在correctValList中就抛出异常
     *
     * @param inputVal       输入数据
     * @param correctValList 列表
     * @param msg
     */
    public static void isNotContainMsg(String inputVal, List<String> correctValList, String msg) {
        if (correctValList == null || !correctValList.contains(inputVal)) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入数据不在correctValList中就抛出异常
     *
     * @param inputVal       输入数据
     * @param correctValList 列表
     * @param msg
     */
    public static void isNotContainMsg(Integer inputVal, List<Integer> correctValList, String msg) {
        if (correctValList == null || !correctValList.contains(inputVal)) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入数据在correctValList中就抛出异常
     *
     * @param inputVal       输入数据
     * @param correctValList 列表
     * @param msg
     */
    public static void isContainMsg(String inputVal, List<String> correctValList, String msg) {
        if (correctValList.contains(inputVal)) {
            throw new TipException(msg);
        }
    }

    /**
     * Double：对比输入数据与正确数据，相等就抛出提示异常
     *
     * @param inputVal
     * @param correctVal
     * @param msg
     */
    public static void isEqualMsg(Number inputVal, Number correctVal, String msg) {
        boolean equ = inputVal == null ? correctVal == null : (correctVal == null ? false : correctVal.doubleValue() == inputVal.doubleValue());
        if (equ) {
            throw new TipException(msg);
        }
    }

    /**
     * Long：对比输入数据与正确数据，不相等就抛出提示异常
     *
     * @param inputVal
     * @param correctVal
     * @param msg
     */
    public static void isNotEqualMsg(Number inputVal, Number correctVal, String msg) {
        boolean equ = inputVal == null ? correctVal == null : (correctVal == null ? false : correctVal.doubleValue() == inputVal.doubleValue());
        if (!equ) {
            throw new TipException(msg);
        }
    }

    /**
     * 如果不在两个数之间，就抛出异常
     *
     * @param inputVal 输入的值
     * @param minVal   需要比较的值 最小值
     * @param maxVal   需要比较的值 最大值
     * @param proName  校验的数据名称
     */
    public static void isNotInBetween(Number inputVal, Number minVal, Number maxVal, String proName) {
        if (inputVal == null) {
            throw new TipException(proName + "不能为空");
        } else if (inputVal.doubleValue() < minVal.doubleValue()) {
            throw new TipException(proName + "不能低于" + minVal);
        } else if (inputVal.doubleValue() > maxVal.doubleValue()) {
            throw new TipException(proName + "不能超过" + minVal);
        }
    }

    /**
     * 如果不在两个数之间，就抛出异常
     *
     * @param inputVal 输入的值
     * @param minVal   需要比较的值 最小值
     * @param maxVal   需要比较的值 最大值
     * @param msg      提示消息
     */
    public static void isNotInBetweenMsg(Number inputVal, Number minVal, Number maxVal, String msg) {
        if (inputVal == null || inputVal.doubleValue() > maxVal.doubleValue() || inputVal.doubleValue() < minVal.doubleValue()) {
            throw new TipException(msg);
        }
    }

    /**
     * 如果在两个数之间，就抛出异常
     *
     * @param inputVal 输入的值
     * @param minVal   需要比较的值 最小值
     * @param maxVal   需要比较的值 最大值
     * @param proName  校验的数据名称
     */
    public static void isInBetween(Number inputVal, Number minVal, Number maxVal, String proName) {
        if (inputVal == null) {
            throw new TipException(proName + "不能为空");
        } else if (inputVal.doubleValue() <= maxVal.doubleValue() && inputVal.doubleValue() >= minVal.doubleValue()) {
            throw new TipException(proName + "不能在" + minVal + "和" + maxVal + "之间");
        }
    }

    /**
     * 如果在两个数之间，就抛出异常
     *
     * @param inputVal 输入的值
     * @param minVal   需要比较的值 最小值
     * @param maxVal   需要比较的值 最大值
     * @param msg      提示消息
     */
    public static void isInBetweenMsg(Number inputVal, Number minVal, Number maxVal, String msg) {
        if (inputVal == null || (inputVal.doubleValue() <= maxVal.doubleValue() && inputVal.doubleValue() >= minVal.doubleValue())) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值大于比较的值，就抛出异常
     *
     * @param inputVal 输入的值
     * @param minVal   需要比较的值
     * @param proName  校验的数据名称
     */
    public static void isGreater(Number inputVal, Number minVal, String proName) {
        if (inputVal == null) {
            throw new TipException(proName + "不能为空");
        } else if (inputVal.doubleValue() > minVal.doubleValue()) {
            throw new TipException(proName + "不能超过" + minVal);
        }
    }

    /**
     * 输入值大于比较的值，就抛出异常
     *
     * @param inputVal 输入的值
     * @param minVal   需要比较的值
     * @param msg      提示消息
     */
    public static void isGreaterMsg(Number inputVal, Number minVal, String msg) {
        if (inputVal == null || minVal == null || inputVal.doubleValue() > minVal.doubleValue()) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值大于或等于比较的值，就抛出异常
     *
     * @param inputVal 输入的值
     * @param minVal   需要比较的值
     * @param proName  校验的数据名称
     */
    public static void isGreaterOrEqual(Number inputVal, Number minVal, String proName) {
        if (inputVal == null) {
            throw new TipException(proName + "不能为空");
        } else if (inputVal.doubleValue() >= minVal.doubleValue()) {
            throw new TipException(proName + "必须小于" + minVal);
        }
    }

    /**
     * 输入值大于或等于比较的值，就抛出异常
     *
     * @param inputVal 输入的值
     * @param minVal   需要比较的值
     * @param msg      提示消息
     */
    public static void isGreaterOrEqualMsg(Number inputVal, Number minVal, String msg) {
        if (inputVal == null || minVal == null || inputVal.doubleValue() >= minVal.doubleValue()) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值小于比较的值，就抛出异常
     *
     * @param inputVal 输入的值
     * @param maxVal   需要比较的值
     * @param proName  校验的数据名称
     */
    public static void isLess(Number inputVal, Number maxVal, String proName) {
        if (inputVal == null) {
            throw new TipException(proName + "不能为空");
        } else if (inputVal.doubleValue() < maxVal.doubleValue()) {
            throw new TipException(proName + "不能低于" + maxVal);
        }
    }

    /**
     * 输入值小于比较的值，就抛出异常
     *
     * @param inputVal 输入的值
     * @param maxVal   需要比较的值
     * @param msg      提示消息
     */
    public static void isLessMsg(Number inputVal, Number maxVal, String msg) {
        if (inputVal == null || maxVal == null || inputVal.doubleValue() < maxVal.doubleValue()) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值小于或等于比较的值，就抛出异常
     *
     * @param inputVal 输入的值
     * @param maxVal   需要比较的值
     * @param proName  校验的数据名称
     */
    public static void isLessOrEqual(Number inputVal, Number maxVal, String proName) {
        if (inputVal == null) {
            throw new TipException(proName + "不能为空");
        } else if (inputVal.doubleValue() <= maxVal.doubleValue()) {
            throw new TipException(proName + "必须大于" + maxVal);
        }
    }

    /**
     * 输入值小于或等于比较的值，就抛出异常
     *
     * @param inputVal 输入的值
     * @param maxVal   需要比较的值
     * @param msg      提示消息
     */
    public static void isLessOrEqualMsg(Number inputVal, Number maxVal, String msg) {
        if (inputVal == null || maxVal == null || inputVal.doubleValue() <= maxVal.doubleValue()) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值大于比较的值，就抛出异常
     *
     * @param inputVal 输入的时间
     * @param minVal   需要比较的时间
     * @param msg      提示消息
     */
    public static void isGreaterMsg(Date inputVal, Date minVal, String msg) {
        if (inputVal == null || minVal == null || inputVal.getTime() > minVal.getTime()) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值大于或等于比较的值，就抛出异常
     *
     * @param inputVal 输入的时间
     * @param minVal   需要比较的时间
     * @param msg      提示消息
     */
    public static void isGreaterOrEqualMsg(Date inputVal, Date minVal, String msg) {
        if (inputVal == null || minVal == null || inputVal.getTime() >= minVal.getTime()) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值小于比较的值，就抛出异常
     *
     * @param inputVal 输入的时间
     * @param minVal   需要比较的时间
     * @param msg      提示消息
     */
    public static void isLessMsg(Date inputVal, Date minVal, String msg) {
        if (inputVal == null || minVal == null || inputVal.getTime() < minVal.getTime()) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值小于或等于比较的值，就抛出异常
     *
     * @param inputVal 输入的时间
     * @param minVal   需要比较的时间
     * @param msg      提示消息
     */
    public static void isLessOrEqualMsg(Date inputVal, Date minVal, String msg) {
        if (inputVal == null || minVal == null || inputVal.getTime() <= minVal.getTime()) {
            throw new TipException(msg);
        }
    }

    /**
     * 如果不在两个时间之间，就抛出异常
     *
     * @param inputVal 输入的时间
     * @param minVal   需要比较的最小时间
     * @param maxVal   需要比较的最大时间
     * @param msg      提示消息
     */
    public static void isNotInBetweenMsg(Date inputVal, Date minVal, Date maxVal, String msg) {
        if (inputVal == null || minVal == null || maxVal == null || inputVal.getTime() < minVal.getTime() || inputVal.getTime() > maxVal.getTime()) {
            throw new TipException(msg);
        }
    }

    /**
     * 如果在两个时间之间，就抛出异常
     *
     * @param inputVal 输入的时间
     * @param minVal   需要比较的最小时间
     * @param maxVal   需要比较的最大时间
     * @param msg      提示消息
     */
    public static void isInBetweenMsg(Date inputVal, Date minVal, Date maxVal, String msg) {
        if (inputVal == null || minVal == null || maxVal == null || (inputVal.getTime() >= minVal.getTime() || inputVal.getTime() <= maxVal.getTime())) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入字符串长度大于最大，就抛出异常
     *
     * @param inputVal  输入字符串
     * @param maxLength 最大长度
     * @param proName   校验的数据名称
     */
    public static void isGreaterLength(String inputVal, int maxLength, String proName) {
        int currLength = inputVal == null ? 0 : inputVal.length();
        if (currLength > maxLength) {
            throw new TipException(proName + "长度最大" + maxLength);
        }
    }

    /**
     * 输入字符串长度大于最大，就抛出异常
     *
     * @param inputVal  输入字符串
     * @param maxLength 最大长度
     * @param msg       提示消息
     */
    public static void isGreaterLengthMsg(String inputVal, int maxLength, String msg) {
        int currLength = inputVal == null ? 0 : inputVal.length();
        if (currLength > maxLength) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入字符串长度小于最小长度，就抛出异常
     *
     * @param inputVal  输入字符串
     * @param minLength 最小长度
     * @param proName   校验的数据名称
     */
    public static void isLessLength(String inputVal, int minLength, String proName) {
        int currLength = inputVal == null ? 0 : inputVal.length();
        if (currLength < minLength) {
            throw new TipException(proName + "长度最少" + minLength);
        }
    }

    /**
     * 输入字符串长度小于最小长度，就抛出异常
     *
     * @param inputVal  输入字符串
     * @param minLength 最小长度
     * @param msg       提示消息
     */
    public static void isLessLengthMsg(String inputVal, int minLength, String msg) {
        int currLength = inputVal == null ? 0 : inputVal.length();
        if (currLength < minLength) {
            throw new TipException(msg);
        }
    }

    /**
     * 输入值字符串长度不在最小长度和最大长度之间，就抛出异常
     *
     * @param inputVal  输入值字符串
     * @param minLength 最小长度
     * @param maxLength 最大长度
     * @param proName   校验的数据名称
     */
    public static void isNotInBetweenLength(String inputVal, int minLength, int maxLength, String proName) {
        int currLength = inputVal == null ? 0 : inputVal.length();
        if (currLength < minLength || currLength > maxLength) {
            throw new TipException(proName + "长度必须在" + minLength + "和" + maxLength + "之间");
        }
    }

    /**
     * 输入值字符串长度不在最小长度和最大长度之间，就抛出异常
     *
     * @param inputVal  输入值字符串
     * @param minLength 最小长度
     * @param maxLength 最大长度
     * @param msg       提示消息
     */
    public static void isNotInBetweenLengthMsg(String inputVal, int minLength, int maxLength, String msg) {
        int currLength = inputVal == null ? 0 : inputVal.length();
        if (currLength < minLength || currLength > maxLength) {
            throw new TipException(msg);
        }
    }

    public static void isNotMoney(String val, String msg) {
        String regex = "^(?:0|[1-9]\\d*)(?:\\.\\d{1,2})?$";
        if (val == null || !isMatch(val, regex, msg)) {
            throw new TipException(msg);
        }
    }

    public static boolean isMatch(String val, String regex, String msg) {
        if (val == null) {
            throw new TipException(msg);
        }
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(val);
        return matcher.matches();
    }

    /**
     * 验证日期(年月日),不是就抛出异常
     *
     * @param str     待验证的字符串
     * @param split   时间分隔符 "-"、"/"、""
     * @param message 提示文字
     */
    public static void isNotDateMsg(String str, String split, String message) {
//        boolean result = DateUtil.isDate(str, split);
//        if (!result) {
//            throw new TipException(message);
//        }
    }

    /**
     * 验证时间（时分秒）,不是就抛出异常
     *
     * @param str         待验证的字符串
     * @param timePattern 格式 ""或null或NORM_TIME_PATTERN：06:53:39  DateUtil.TIME_PATTERN_HH_mm：12:30  DateUtil.TIME_PATTERN_mm_ss 45:23
     * @param message     提示文字
     */
    public static void isNotTimeMsg(String str, String timePattern, String message) {
//        boolean result = DateUtil.isTime(str, timePattern);
//        if (!result) {
//            throw new TipException(message);
//        }
    }

    /**
     * 验证日期时间(年月日时分秒),不是就抛出异常
     * yyyy-MM-dd HH:mm:ss
     *
     * @param str     待验证的字符串
     * @param split   时间分隔符 "-"、"/"、""
     * @param message 提示文字
     */
    public static void isNotDateTimeMsg(String str, String split, String message) {
//        boolean result = DateUtil.isDateTime(str, "-");
//        if (!result) {
//            throw new TipException(message);
//        }
    }

    public static void hasNoPermission(String permission, String message) {
//        boolean result = UserUtil.hasPermission(permission);
//        if(!result){
//            throw new TipException(message);
//        }
    }
    public static void hasPermission(String permission, String message) {
//        boolean result = UserUtil.hasPermission(permission);
//        if(result){
//            throw new TipException(message);
//        }
    }


    /**
     * 验证验证输入 "大于零的两位小数：最多两位小数,小数可有可无，大于1的数首位不能为0"
     *
     * @param str 待验证的字符串
     * @throws TipException
     */
    public static void isNotGreaterZeroDecimalMsg(String str, String message) {
        boolean result = false;
        if (str == null) {
            result = false;
        } else {
            String regex = "^(?!0+(?:\\.0+)?$)(?:[1-9]\\d*|0)(?:\\.\\d{1,2})?$";
//            result = ToolUtil.match(regex, str);
        }
        if (!result) {
            throw new TipException(message);
        }
    }

    /**
     * 验证验证输入 "大于零的整数"
     *
     * @param str 待验证的字符串
     * @throws TipException
     */
    public static void isNotGreaterZeroIntMsg(String str, String message) {
        boolean result = false;
        if (str == null) {
            result = false;
        } else {//
            String regex = "^\\+?[1-9]\\d*$";
//            result = ToolUtil.match(regex, str);

        }
        if (!result) {
            throw new TipException(message);
        }
    }


    public static void tipException(String message) {
        throw new TipException(message);
    }
    public static void tipException(String code,String message) {
        throw new TipException(code,message);
    }
    public static void main(String[] args) {
        Integer o = null;
        String nullString = null;
        String emptyString = "  ";
        ArrayList<Object> emptyList = new ArrayList<>();
        ArrayList<Object> nullList = null;
       isBlankMsg(emptyString,"空空的");
    }

//		try {
//			String date1 = "2022-09-11 00:00:01";
//			String date2 = "2022-09-11 00:00:00";
//			String time = "00:00:00";
////			TipUtil.isDateTime(date);
//
//			System.out.println(DateUtil.isDateTime("2012-05-16 23:60:33","-"));
//			TipUtil.isGreaterZeroInt("222","cccc");
//		} catch (TipException e) {
//			System.out.println("111111111");
//			e.printStackTrace();
//		} catch (Exception e) {
//			System.out.println("22222");
//			e.printStackTrace();
//		}
//	}
}
